package yijy.example;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;

public class MathExtend {
	// 默认除法运算精度
	private static final int DEFAULT_DIV_SCALE = 10;

	/**
	 * 提供精确的加法运算
	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数数学加和，以字符串格式返回
	 */
	public static String add(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.add(b2).toString();
	}

	/**
	 * 提供精确的减法运算
	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数数学差，以字符串格式返回
	 */
	public static String subtract(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.subtract(b2).toString();
	}

	/**
	 * 提供精确的乘法运算
	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数的数学积，以字符串格式返回
	 */
	public static String multiply(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.multiply(b2).toString();
	}

	public static String cifang(String v,int cfnum){
		String tmpv=v;
		for(int i=1;i<cfnum;i++){
			tmpv=multiply(tmpv,v);
		}
		return tmpv;
	}

	/**
	 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
	 * 
	 * @param v1
	 * @param v2
	 * @return 两个参数的商，以字符串格式返回
	 */
	public static String divide(String v1, String v2) {
		return divide(v1, v2, DEFAULT_DIV_SCALE);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
	 * 
	 * @param v1
	 * @param v2
	 * @param scale
	 *            表示需要精确到小数点以后几位
	 * @return 两个参数的商，以字符串格式返回
	 */
	public static String divide(String v1, String v2, int scale) {
		return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
	 * 
	 * @param v1
	 * @param v2
	 * @param scale
	 *            表示需要精确到小数点以后几位
	 * @param round_mode
	 *            表示用户指定的舍入模式
	 * @return 两个参数的商，以字符串格式返回
	 */
	public static String divide(String v1, String v2, int scale, int round_mode) {
		//if (Integer.parseInt(v2) == 0)
		//	return "0";
		if(Float.parseFloat(v2)==0){
			return "0";
		}
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.divide(b2, scale, round_mode).toString();
	}

	/**
	 * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
	 * 
	 * @param v
	 *            需要四舍五入的数字
	 * @param scale
	 *            小数点后保留几位
	 * @return 四舍五入后的结果，以字符串格式返回
	 */
	public static String round(String v, int scale) {
		return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
	}

	/**
	 * 提供精确的小数位四舍五入处理
	 * 
	 * @param v
	 *            需要四舍五入的数字
	 * @param scale
	 *            小数点后保留几位
	 * @param round_mode
	 *            指定的舍入模式
	 * @return 四舍五入后的结果，以字符串格式返回
	 */
	public static String round(String v, int scale, int round_mode) {
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(v);
		return b.setScale(scale, round_mode).toString();
	}
	
	public static float stringToFloat(String v,int scale){
		BigDecimal b = new BigDecimal(v);
		return b.setScale(scale, BigDecimal.ROUND_CEILING).floatValue();
	}
    public static double stringToDouble(String v,int scale){
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_CEILING).doubleValue();
    }
	/**
	 * 保留两位小数
	 * 
	 * @param v
	 * @return
	 */
	public static String round2Ceiling(String v) {
		BigDecimal b = new BigDecimal(v);
		return b.setScale(2, BigDecimal.ROUND_CEILING).toString();
	}

    /**
     * 格式化float类型数据
     * @param f
     * @param format
     * @return
     */
	public static String decimalFormat(float f,String format)
	{
		 DecimalFormat   fnum  =   new  DecimalFormat(format);    
		 return fnum.format(f);     
	}

    /**
     * 格式化Double类型的数据
     * @param f
     * @param format
     * @return
     */
	public static String decimalFormat(Double f,String format)
	{
		 DecimalFormat   fnum  =   new  DecimalFormat(format);    
		 return fnum.format(f);     
	}


    /**
     * 比较大小 v1<v2 -1,v1==v2 0,v1>v2 1
     * @author rain-hms
     * @param v1
     * @param v2
     * @return
     */
    public static int compareString(String v1, String v2){
    	BigDecimal b1 = new BigDecimal(v1);
		BigDecimal b2 = new BigDecimal(v2);
		return b1.compareTo(b2);
    }

    /**
     * 比较大小 v1小于v2返回-1,v1等于v2返回0,v1大于v2返回1
     * @author rain-hms
     * @param v1
     * @param v2
     * @return
     */
    public static int compareDouble(double v1, double v2){
    	BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.compareTo(b2);
    }
    
    /**
	 * 提供精确的加法运算
	 * @author rain-hms
	 * @param v1
	 * @param v2
	 * @return 两个参数数学加和，以字符串格式返回
	 */
	public static double addDouble(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.add(b2).doubleValue();
	}

	/**
	 * 提供精确的减法运算
	 * @author rain-hms
	 * @param v1
	 * @param v2
	 * @return 两个参数数学差，以字符串格式返回
	 */
	public static double subtractDouble(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.subtract(b2).doubleValue();
	}

	/**
	 * 字符串数字保留2位小数
	 * @param v1
	 * @return
	 */
	public static double doubleFormat(double v1) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));  
		double v2 = b1.setScale(2, RoundingMode.HALF_UP).doubleValue();
		return v2;
	}

}
